// import { Provide } from '@midwayjs/core';
// import { BaseService } from '@cool-midway/core';
// import { InjectEntityModel } from '@midwayjs/typeorm';
// import { Repository, MoreThan, LessThan } from 'typeorm';

// /**
//  * 设备状态服务
//  */
// @Provide()
// export class AutomationDeviceStatusService extends BaseService {
//   @InjectEntityModel(AutomationDeviceStatusEntity)
//   automationDeviceStatusEntity: Repository<AutomationDeviceStatusEntity>;

//   /**
//    * 更新设备状态
//    * @param deviceId
//    * @param status
//    */
//   async updateDeviceStatus(deviceId: string, status: any) {
//     const deviceStatus = new AutomationDeviceStatusEntity();
//     deviceStatus.deviceId = deviceId;
//     deviceStatus.status = status;
//     deviceStatus.reportTime = new Date();

//     return await this.automationDeviceStatusEntity.save(deviceStatus);
//   }

//   /**
//    * 获取设备最新状态
//    * @param deviceId
//    */
//   async getLatestStatus(deviceId?: string) {
//     const queryBuilder = this.automationDeviceStatusEntity.createQueryBuilder('status');

//     if (deviceId) {
//       queryBuilder.where('status.deviceId = :deviceId', { deviceId });
//     }

//     queryBuilder.orderBy('status.reportTime', 'DESC');

//     if (deviceId) {
//       return await queryBuilder.getOne();
//     } else {
//       // 获取所有设备的最新状态
//       const subQuery = this.automationDeviceStatusEntity
//         .createQueryBuilder('sub')
//         .select('sub.deviceId')
//         .addSelect('MAX(sub.reportTime)', 'maxReportTime')
//         .groupBy('sub.deviceId');

//       return await queryBuilder
//         .innerJoin(
//           `(${subQuery.getQuery()})`,
//           'latest',
//           'status.deviceId = latest.deviceId AND status.reportTime = latest.maxReportTime'
//         )
//         .setParameters(subQuery.getParameters())
//         .getMany();
//     }
//   }

//   /**
//    * 获取设备状态历史
//    * @param deviceId
//    * @param limit
//    */
//   async getDeviceHistory(deviceId: string, limit: number = 100) {
//     return await this.automationDeviceStatusEntity.find({
//       where: { deviceId },
//       order: { reportTime: 'DESC' },
//       take: limit
//     });
//   }

//   /**
//    * 获取在线设备列表
//    */
//   async getOnlineDevices() {
//     const fiveMinutesAgo = new Date();
//     fiveMinutesAgo.setMinutes(fiveMinutesAgo.getMinutes() - 5);

//     const latestStatuses = await this.getLatestStatus();
//     return latestStatuses.filter(status =>
//       status.reportTime > fiveMinutesAgo &&
//       status.status &&
//       status.status.online !== false
//     );
//   }

//   /**
//    * 获取离线设备列表
//    */
//   async getOfflineDevices() {
//     const fiveMinutesAgo = new Date();
//     fiveMinutesAgo.setMinutes(fiveMinutesAgo.getMinutes() - 5);

//     const latestStatuses = await this.getLatestStatus();
//     return latestStatuses.filter(status =>
//       status.reportTime <= fiveMinutesAgo ||
//       !status.status ||
//       status.status.online === false
//     );
//   }

//   /**
//    * 获取设备状态统计
//    */
//   async getStatistics() {
//     const total = await this.automationDeviceStatusEntity
//       .createQueryBuilder('status')
//       .select('COUNT(DISTINCT status.deviceId)', 'count')
//       .getRawOne();

//     const onlineDevices = await this.getOnlineDevices();
//     const offlineDevices = await this.getOfflineDevices();

//     const totalDevices = parseInt(total.count);
//     const onlineCount = onlineDevices.length;
//     const offlineCount = offlineDevices.length;

//     return {
//       total: totalDevices,
//       online: onlineCount,
//       offline: offlineCount,
//       onlineRate: totalDevices > 0 ? Math.round((onlineCount / totalDevices) * 100) : 0,
//       offlineRate: totalDevices > 0 ? Math.round((offlineCount / totalDevices) * 100) : 0
//     };
//   }

//   /**
//    * 清理历史数据
//    * @param cutoffDate
//    */
//   async cleanupHistory(cutoffDate: Date) {
//     return await this.automationDeviceStatusEntity.delete({
//       reportTime: LessThan(cutoffDate)
//     });
//   }

//   /**
//    * 获取设备状态变化趋势
//    * @param deviceId
//    * @param hours
//    */
//   async getStatusTrend(deviceId: string, hours: number = 24) {
//     const startTime = new Date();
//     startTime.setHours(startTime.getHours() - hours);

//     const statusHistory = await this.automationDeviceStatusEntity.find({
//       where: {
//         deviceId,
//         reportTime: MoreThan(startTime)
//       },
//       order: { reportTime: 'ASC' }
//     });

//     // 按小时分组统计
//     const hourlyData = {};
//     statusHistory.forEach(status => {
//       const hour = new Date(status.reportTime).getHours();
//       if (!hourlyData[hour]) {
//         hourlyData[hour] = [];
//       }
//       hourlyData[hour].push(status);
//     });

//     return Object.keys(hourlyData).map(hour => ({
//       hour: parseInt(hour),
//       count: hourlyData[hour].length,
//       avgStatus: this.calculateAverageStatus(hourlyData[hour])
//     }));
//   }

//   /**
//    * 计算平均状态
//    * @param statuses
//    */
//   private calculateAverageStatus(statuses: AutomationDeviceStatusEntity[]) {
//     if (statuses.length === 0) return null;

//     // 这里可以根据实际的状态数据结构来计算平均值
//     // 例如：温度、湿度等数值型数据的平均值
//     const numericFields = ['temperature', 'humidity', 'battery'];
//     const avgStatus = {};

//     numericFields.forEach(field => {
//       const values = statuses
//         .map(s => s.status && s.status[field])
//         .filter(v => v !== undefined && v !== null && !isNaN(v));

//       if (values.length > 0) {
//         avgStatus[field] = values.reduce((sum, val) => sum + val, 0) / values.length;
//       }
//     });

//     return avgStatus;
//   }

//   /**
//    * 获取报告数据
//    * @param deviceIds
//    * @param startTime
//    * @param endTime
//    */
//   async getReportData(deviceIds?: string[], startTime?: string, endTime?: string) {
//     const queryBuilder = this.automationDeviceStatusEntity.createQueryBuilder('status');

//     if (deviceIds && deviceIds.length > 0) {
//       queryBuilder.andWhere('status.deviceId IN (:...deviceIds)', { deviceIds });
//     }

//     if (startTime) {
//       queryBuilder.andWhere('status.reportTime >= :startTime', { startTime });
//     }

//     if (endTime) {
//       queryBuilder.andWhere('status.reportTime <= :endTime', { endTime });
//     }

//     queryBuilder.orderBy('status.deviceId', 'ASC')
//                .addOrderBy('status.reportTime', 'DESC');

//     const data = await queryBuilder.getMany();

//     // 按设备分组
//     const groupedData = {};
//     data.forEach(status => {
//       if (!groupedData[status.deviceId]) {
//         groupedData[status.deviceId] = [];
//       }
//       groupedData[status.deviceId].push(status);
//     });

//     return {
//       summary: {
//         totalRecords: data.length,
//         deviceCount: Object.keys(groupedData).length,
//         timeRange: { startTime, endTime }
//       },
//       deviceData: groupedData
//     };
//   }
// }
